/*->c.ana */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <ctype.h>
#include <time.h>
#include <locale.h>

#include "h.os"
#include "h.wimp"
#include "h.sprite"
#include "h.wimpt"
#include "h.bbc"
#include "h.akbd"
#include "h.werr"
#include "h.swis"
#include "h.font"

#include "h.drawlevel0"


#include "h.def"

#include "h.wos"
#include "h.ram"
#include "h.mym"
#include "h.file"
#include "h.dc"
#include "h.sp"

#include "h.vm"

#include "h.main"


#include "h.ana"




int    loadtype;
int    loadsize;

buffer * textsrc;
buffer * asrc;
buffer * anasrc;

static int abytes;
static int alen;

static void xaddword(char * p)
{
 int    len;
 char * buff;

 len=strlen(p);

 if((abytes+len)>=alen)
 {
  alen+=0x1000;
  alen=setsizebuffer(&anasrc,alen);

  if(alen<=abytes)                                                                {
   nomem();
   return;
  }   /* ran out of memory */
 }

 formblock(anasrc,0,alen);
 buff=charbuffer(anasrc,abytes);
 strcpy(buff,p);
 abytes+=len;
}






static int xcmpchar(const void * p1,const void * p2)
{
 return((*(char*)p2)-(*(char*)p1));
}




static void xanagramsearch(char * string)
{
 word   words;
 dict * dp;
 int    dc;
 int    len;
 int    i;
 int    j;
 int    ct;
 char   b[STRLEN];
 int    check;

 hourglasson();

 len=strlen(string);

 qsort(string,len,1,xcmpchar);

 check=0;

 for(dc=0;dc<nodc;dc++)
 {
  dp=&dtable[dcmap[dc]].dictp;

  locword(0,dp,&words);
  do
  {
   if(len==strlen(words.string))
   {
    strcpy(b,string);
    for(ct=0,i=0;i<len;i++)
    {
     if(ct!=i) break;
     for(j=0;j<len;j++)
      if(b[j]==words.string[i] || b[j]=='*')
      {
       b[j]=0;
       ct++;
       break;
      }
    }

    if(i==len && ct==len)
    {
     xaddword(words.string);
     xaddword("\n");
    }
   }

   if(check++==2048)
   {
    check=0;
    if(bbc_inkey(0)==27)
    {
     check=-1;
     break;
    }
   }
  } while(nextword(dp,&words));
  if(check<0) break;
 }

 hourglassoff();
}





static void makeanagrams(void)
{
 int i;
 int c;
 int n;
 char word[64];


 if(!anasrc) createbuffer(&anasrc);

 n=0;
 abytes=0;
 alen=0;

 for(i=0;i<loadsize;i++)
 {
  c=*charbuffer(textsrc,i);
  if(isalpha(c) || c=='*') word[n++]=c;

  if(!(isalpha(c) || c=='*') || i==(loadsize-1) || n==63)
  {
   word[n]=0;

   xaddword(word);
   xaddword("\n");
   xaddword("\n");

   xanagramsearch(word);
   xaddword("\n");
   xaddword("\n");


   n=0;
  }
 }

 setsizebuffer(&anasrc,abytes);
 savecheck();
}


int checkfile(char * filename)
{
 FILE * fp;
 int code;
 int len;
 int bytes;
 char * buff;

 code=0;

 if((fp=ropen(filename,"rb"))!=NULL)
 {
  len=0x2000;
  bytes=0;

  if(!textsrc) createbuffer(&textsrc);

  while(1)
  {
   len=setsizebuffer(&textsrc,len);

   if(len<=bytes)
   {
    nomem();
    return(0);
   }   /* ran out of memory */

   formblock(textsrc,0,len);
   buff=charbuffer(textsrc,0);

   bytes+=rread(buff+bytes,1,len-bytes,fp);
   if(rameof(fp)) break;
   if(rerror(fp)) break;
   len+=0x2000;
  }

  if(bytes!=len) setsizebuffer(&textsrc,bytes);
  loadsize=bytes;
  rclose(fp);
 }

 makeanagrams();

 return(code);
}



int savetext(char * filename)
{
 int    code;
 FILE * fp;
 int    len;

 code=0;

 if((fp=ropen(filename,"wb"))!=NULL)
 {
  len=SIZEBUFF(anasrc);
  formblock(anasrc,0,len);
  rwrite(charbuffer(anasrc,0),len,1,fp);
  savetypeclose(fp,filename);
 }

 return(1);
}


void trashcheck(void)
{
 deletebuffer(&textsrc);
 deletebuffer(&anasrc);
}


void savezero(void)
{
 if(whandle[SAVEFILE0])
 {
  getw(whandle[SAVEFILE0]);
  if(wflags & 10000) return;
 }
 remzeroevent(SAVEZERO);
 trashcheck();
}


void savecheck(void)
{
 opensave(SAVEFILE);
 addzeroevent(SAVEZERO);
}



